home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / memory / xms200je / xmstest.cpp < prev    next >
C/C++ Source or Header  |  1993-11-22  |  8KB  |  296 lines
  1. //--------------------------------------------------------------------------
  2. //
  3. //      XMSTEST.CPP: Test program for XMS class.
  4. //      Copyright (c) J.English 1993.
  5. //      Author's address: je@unix.brighton.ac.uk
  6. //
  7. //      Permission is granted to use copy and distribute the
  8. //      information contained in this file provided that this
  9. //      copyright notice is retained intact and that any software
  10. //      or other document incorporating this file or parts thereof
  11. //      makes the source code for the library of which this file
  12. //      is a part freely available.
  13. //
  14. //--------------------------------------------------------------------------
  15. //
  16. //      Revision history:
  17. //      2.0     Nov 1993        Initial coding
  18. //
  19. //--------------------------------------------------------------------------
  20.  
  21. #include "xms.h"
  22. #include "doserror.h"
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <time.h>
  26.  
  27.  
  28. //--------------------------------------------------------------------------
  29. //
  30. //      Global data.
  31. //
  32. DOSerror e;             // guard against critical errors and control-breaks
  33. XMS* desc [100];        // array of pointers to XMS descriptors
  34. int ndesc = 0;          // number of descriptors
  35.  
  36.  
  37. //--------------------------------------------------------------------------
  38. //
  39. //      Function prototypes.
  40. //
  41. char menu ();           // display menu & get user's choice
  42. void XMSstats ();       // 1. XMS statistics
  43. void blocksizes ();     // 2. List block sizes
  44. void allocate ();       // 3. Allocate block
  45. void deallocate ();     // 4. Deallocate block
  46. void copy ();           // 5. Copy block
  47. void resize ();         // 6. Resize block
  48.  
  49. //--------------------------------------------------------------------------
  50. //
  51. //      Main program.
  52. //
  53. //      A menu of choices is displayed, allowing the user to exercise
  54. //      each of the XMS functions available (with the exception of
  55. //      XMS-to-XMS copying).
  56. //
  57. void main ()
  58. {
  59.     XMSstats();
  60.  
  61.     char choice;
  62.     for (;;)
  63.     {
  64.         choice = menu ();
  65.         if (choice == 'X')
  66.             break;
  67.  
  68.         switch (choice)
  69.         {
  70.             case '1':
  71.                 XMSstats ();
  72.                 break;
  73.             case '2':
  74.                 blocksizes ();
  75.                 break;
  76.             case '3':
  77.                 allocate ();
  78.                 break;
  79.             case '4':
  80.                 deallocate ();
  81.                 break;
  82.             case '5':
  83.                 copy ();
  84.                 break;
  85.             case '6':
  86.                 resize ();
  87.                 break;
  88.         }
  89.     }
  90.     for (int i = 0; i < ndesc; i++)
  91.         delete desc[i];
  92. }
  93.  
  94. //--------------------------------------------------------------------------
  95. //
  96. //      Display menu and get user choice.
  97. //
  98. //      The choice must be a line containing a single character from 1 to 6
  99. //      (or X for exit).
  100. //
  101. char menu ()
  102. {
  103.     printf ("\nChoose desired operation:\n"
  104.             "  1) XMS statistics\n"
  105.             "  2) List block sizes\n"
  106.             "  3) Allocate block\n"
  107.             "  4) Deallocate block\n"
  108.             "  5) Copy block\n"
  109.             "  6) Resize block\n"
  110.             "  X) Exit program\n");
  111.     char buff [80];
  112.     for (;;)
  113.     {
  114.         printf ("Enter your choice: ");
  115.         fgets (buff, 80, stdin);
  116.         if ((buff[0] == 'x' || buff[0] == 'X') && buff[1] == '\n')
  117.             return 'X';
  118.         if (buff[0] < '1' || buff[0] > '6' || buff[1] != '\n')
  119.             printf ("Invalid choice!\a\n");
  120.         else
  121.             break;
  122.     }
  123.     printf ("\n");
  124.     return buff[0];
  125. }
  126.  
  127.  
  128. //--------------------------------------------------------------------------
  129. //
  130. //      Display XMS statistics.
  131. //
  132. void XMSstats ()
  133. {
  134.     printf ("XMS available: %ld bytes\nLargest block: %ld bytes\n",
  135.             XMS::available(), XMS::largest());
  136. }
  137.  
  138.  
  139. //--------------------------------------------------------------------------
  140. //
  141. //      List block sizes.
  142. //
  143. void blocksizes ()
  144. {
  145.     int flag = 0;
  146.     for (int i = 0; i < ndesc; i++)
  147.     {   if (desc[i] != 0)
  148.         {   printf ("Block %d: size = %ld\n", i+1, desc[i]->size());
  149.             flag = 1;
  150.         }
  151.     }
  152.     if (flag == 0)
  153.         printf ("No blocks allocated!\n");
  154. }
  155.  
  156. //--------------------------------------------------------------------------
  157. //
  158. //      Allocate block.
  159. //
  160. //      Attempt to allocate a new block of a specified size and report the
  161. //      result.
  162. //
  163. void allocate ()
  164. {
  165.     printf ("Enter block size: ");
  166.     long size;
  167.     scanf ("%ld", &size);
  168.     while (getchar() != '\n')
  169.         continue;
  170.     desc [ndesc++] = new XMS (size);
  171.     printf ("Block %d: ", ndesc);
  172.     printf ("requested %ld bytes, granted %ld bytes.\n",
  173.             size, desc[ndesc-1]->size());
  174.     if (!desc[ndesc-1]->valid())
  175.         delete desc[--ndesc];
  176. }
  177.  
  178.  
  179. //--------------------------------------------------------------------------
  180. //
  181. //      Deallocate block.
  182. //
  183. //      Attempt to deallocate an existing block and report the result.
  184. //
  185. void deallocate ()
  186. {
  187.     printf ("Enter block number: ");
  188.     int b;
  189.     scanf ("%d", &b); b--;
  190.     while (getchar() != '\n')
  191.         continue;
  192.     if (b < 0 || b >= ndesc || desc[b] == 0)
  193.         printf ("No such block!\n");
  194.     else
  195.     {   delete desc[b];
  196.         desc[b] = 0;
  197.         printf ("Block %d deallocated.\n", b+1);
  198.     }
  199. }
  200.  
  201. //--------------------------------------------------------------------------
  202. //
  203. //      Copy to/from XMS.
  204. //
  205. //      Prompts for a block number and a transfer size.  An array of random
  206. //      numbers of the specified size is created in conventional memory,
  207. //      copied to the specified block starting at the specified offset,
  208. //      copied back to conventional memory, and finally compared with the
  209. //      original block.
  210. //
  211. void copy ()
  212. {
  213.     printf ("Enter block number:  ");
  214.     int b;
  215.     scanf ("%d", &b); b--;
  216.     while (getchar() != '\n')
  217.         continue;
  218.     if (b < 0 || b >= ndesc || desc[b] == 0)
  219.     {   printf ("No such block!\n");
  220.         return;
  221.     }
  222.  
  223.     printf ("Enter transfer size: ");
  224.     unsigned s;
  225.     scanf ("%u", &s);
  226.     while (getchar() != '\n')
  227.         continue;
  228.     char* x = new char [s];
  229.     char* y = new char [s];
  230.     if (x == 0 || y == 0)
  231.     {   printf ("Not enough real memory!\n");
  232.         return;
  233.     }
  234.  
  235.     printf ("Enter block offset:  ");
  236.     long p;
  237.     scanf ("%ld", &p);
  238.     while (getchar() != '\n')
  239.         continue;
  240.     printf ("Copying %u bytes to/from XMS block %d, offset %ld.\n", s, b, p);
  241.     printf ("Generating random data... "); fflush (stdout);
  242.     randomize ();
  243.     for (unsigned i = 0; i < s; i++)
  244.         x[i] = random (256);
  245.     printf ("done.\n");
  246.  
  247.     XMS::error r = XMS::copy (desc[b]->at(p), x, s);
  248.     printf ("Random data copied to XMS, result code %02X\n", int(r));
  249.     if (r == XMS::SUCCESS)
  250.     {   r = XMS::copy (y, desc[b]->at(p), s);
  251.         printf ("Data copied back from XMS, result code %02X\n", int(r));
  252.         if (r == XMS::SUCCESS)
  253.         {   for (i = 0; i < s; i++)
  254.             {   if (x[i] != y[i])
  255.                 {   printf ("Verification error at offset %u.\n", i);
  256.                     break;
  257.                 }
  258.             }
  259.             if (i == s)
  260.                 printf ("Copy verified successfully.\n");
  261.         }
  262.     }
  263.     delete x;
  264.     delete y;
  265. }
  266.  
  267. //--------------------------------------------------------------------------
  268. //
  269. //      Resize an existing block.
  270. //
  271. //      Attempt to resize an existing XMS allocation and report the result.
  272. //
  273. void resize ()
  274. {
  275.     printf ("Enter block number: ");
  276.     int b;
  277.     scanf ("%d", &b); b--;
  278.     while (getchar() != '\n')
  279.         continue;
  280.     if (b < 0 || b >= ndesc || desc[b] == 0)
  281.     {   printf ("No such block!\n");
  282.         return;
  283.     }
  284.  
  285.     printf ("Current size:   %ld\nEnter new size: ", desc[b]->size());
  286.     long size;
  287.     scanf ("%ld", &size);
  288.     while (getchar() != '\n')
  289.         continue;
  290.     XMS::error r = desc[b]->resize (size);
  291.     if (r == XMS::SUCCESS)
  292.         printf ("Requested %ld, granted %ld.\n", size, desc[b]->size());
  293.     else
  294.         printf ("Resize failed: error code = %02X\n", int(r));
  295. }
  296.